home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / ppc-amigaos / include / powerup / ppcpragmas / locale_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-02-28  |  15KB  |  501 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_LOCALE_H
  4. #define _PPCPRAGMA_LOCALE_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__LOCALE_H
  7. #include <powerup/ppcinline/locale.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef LOCALE_BASE_NAME
  24. #define LOCALE_BASE_NAME LocaleBase
  25. #endif /* !LOCALE_BASE_NAME */
  26.  
  27. #define    CloseCatalog(catalog)    _CloseCatalog(LOCALE_BASE_NAME, catalog)
  28.  
  29. static __inline void
  30. _CloseCatalog(void *LocaleBase, struct Catalog *catalog)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a0        =(ULONG) catalog;
  40.     MyCaos.caos_Un.Offset    =    (-36);
  41.     MyCaos.a6        =(ULONG) LocaleBase;    
  42.     PPCCallOS(&MyCaos);
  43. }
  44.  
  45. #define    CloseLocale(locale)    _CloseLocale(LOCALE_BASE_NAME, locale)
  46.  
  47. static __inline void
  48. _CloseLocale(void *LocaleBase, struct Locale *locale)
  49. {
  50. struct Caos    MyCaos;
  51.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  52. //    MyCaos.M68kStart    =    NULL;
  53. //    MyCaos.M68kSize        =    0;
  54.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  55. //    MyCaos.PPCStart        =    NULL;
  56. //    MyCaos.PPCSize        =    0;
  57.     MyCaos.a0        =(ULONG) locale;
  58.     MyCaos.caos_Un.Offset    =    (-42);
  59.     MyCaos.a6        =(ULONG) LocaleBase;    
  60.     PPCCallOS(&MyCaos);
  61. }
  62.  
  63. #define    ConvToLower(locale, character)    _ConvToLower(LOCALE_BASE_NAME, locale, character)
  64.  
  65. static __inline ULONG
  66. _ConvToLower(void *LocaleBase, struct Locale *locale, unsigned long character)
  67. {
  68. struct Caos    MyCaos;
  69.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  70. //    MyCaos.M68kStart    =    NULL;
  71. //    MyCaos.M68kSize        =    0;
  72.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  73. //    MyCaos.PPCStart        =    NULL;
  74. //    MyCaos.PPCSize        =    0;
  75.     MyCaos.a0        =(ULONG) locale;
  76.     MyCaos.d0        =(ULONG) character;
  77.     MyCaos.caos_Un.Offset    =    (-48);
  78.     MyCaos.a6        =(ULONG) LocaleBase;    
  79.     return((ULONG)PPCCallOS(&MyCaos));
  80. }
  81.  
  82. #define    ConvToUpper(locale, character)    _ConvToUpper(LOCALE_BASE_NAME, locale, character)
  83.  
  84. static __inline ULONG
  85. _ConvToUpper(void *LocaleBase, struct Locale *locale, unsigned long character)
  86. {
  87. struct Caos    MyCaos;
  88.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  89. //    MyCaos.M68kStart    =    NULL;
  90. //    MyCaos.M68kSize        =    0;
  91.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  92. //    MyCaos.PPCStart        =    NULL;
  93. //    MyCaos.PPCSize        =    0;
  94.     MyCaos.a0        =(ULONG) locale;
  95.     MyCaos.d0        =(ULONG) character;
  96.     MyCaos.caos_Un.Offset    =    (-54);
  97.     MyCaos.a6        =(ULONG) LocaleBase;    
  98.     return((ULONG)PPCCallOS(&MyCaos));
  99. }
  100.  
  101. #define    FormatDate(locale, fmtTemplate, date, putCharFunc)    _FormatDate(LOCALE_BASE_NAME, locale, fmtTemplate, date, putCharFunc)
  102.  
  103. static __inline void
  104. _FormatDate(void *LocaleBase, struct Locale *locale, STRPTR fmtTemplate, struct DateStamp *date, struct Hook *putCharFunc)
  105. {
  106. struct Caos    MyCaos;
  107.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  108. //    MyCaos.M68kStart    =    NULL;
  109. //    MyCaos.M68kSize        =    0;
  110.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  111. //    MyCaos.PPCStart        =    NULL;
  112. //    MyCaos.PPCSize        =    0;
  113.     MyCaos.a0        =(ULONG) locale;
  114.     MyCaos.a1        =(ULONG) fmtTemplate;
  115.     MyCaos.a2        =(ULONG) date;
  116.     MyCaos.a3        =(ULONG) putCharFunc;
  117.     MyCaos.caos_Un.Offset    =    (-60);
  118.     MyCaos.a6        =(ULONG) LocaleBase;    
  119.     PPCCallOS(&MyCaos);
  120. }
  121.  
  122. #define    FormatString(locale, fmtTemplate, dataStream, putCharFunc)    _FormatString(LOCALE_BASE_NAME, locale, fmtTemplate, dataStream, putCharFunc)
  123.  
  124. static __inline APTR
  125. _FormatString(void *LocaleBase, struct Locale *locale, STRPTR fmtTemplate, APTR dataStream, struct Hook *putCharFunc)
  126. {
  127. struct Caos    MyCaos;
  128.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  129. //    MyCaos.M68kStart    =    NULL;
  130. //    MyCaos.M68kSize        =    0;
  131.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  132. //    MyCaos.PPCStart        =    NULL;
  133. //    MyCaos.PPCSize        =    0;
  134.     MyCaos.a0        =(ULONG) locale;
  135.     MyCaos.a1        =(ULONG) fmtTemplate;
  136.     MyCaos.a2        =(ULONG) dataStream;
  137.     MyCaos.a3        =(ULONG) putCharFunc;
  138.     MyCaos.caos_Un.Offset    =    (-66);
  139.     MyCaos.a6        =(ULONG) LocaleBase;    
  140.     return((APTR)PPCCallOS(&MyCaos));
  141. }
  142.  
  143. #define    GetCatalogStr(catalog, stringNum, defaultString)    _GetCatalogStr(LOCALE_BASE_NAME, catalog, stringNum, defaultString)
  144.  
  145. static __inline STRPTR
  146. _GetCatalogStr(void *LocaleBase, struct Catalog *catalog, long stringNum, STRPTR defaultString)
  147. {
  148. struct Caos    MyCaos;
  149.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  150. //    MyCaos.M68kStart    =    NULL;
  151. //    MyCaos.M68kSize        =    0;
  152.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  153. //    MyCaos.PPCStart        =    NULL;
  154. //    MyCaos.PPCSize        =    0;
  155.     MyCaos.a0        =(ULONG) catalog;
  156.     MyCaos.d0        =(ULONG) stringNum;
  157.     MyCaos.a1        =(ULONG) defaultString;
  158.     MyCaos.caos_Un.Offset    =    (-72);
  159.     MyCaos.a6        =(ULONG) LocaleBase;    
  160.     return((STRPTR)PPCCallOS(&MyCaos));
  161. }
  162.  
  163. #define    GetLocaleStr(locale, stringNum)    _GetLocaleStr(LOCALE_BASE_NAME, locale, stringNum)
  164.  
  165. static __inline STRPTR
  166. _GetLocaleStr(void *LocaleBase, struct Locale *locale, unsigned long stringNum)
  167. {
  168. struct Caos    MyCaos;
  169.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  170. //    MyCaos.M68kStart    =    NULL;
  171. //    MyCaos.M68kSize        =    0;
  172.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  173. //    MyCaos.PPCStart        =    NULL;
  174. //    MyCaos.PPCSize        =    0;
  175.     MyCaos.a0        =(ULONG) locale;
  176.     MyCaos.d0        =(ULONG) stringNum;
  177.     MyCaos.caos_Un.Offset    =    (-78);
  178.     MyCaos.a6        =(ULONG) LocaleBase;    
  179.     return((STRPTR)PPCCallOS(&MyCaos));
  180. }
  181.  
  182. #define    IsAlNum(locale, character)    _IsAlNum(LOCALE_BASE_NAME, locale, character)
  183.  
  184. static __inline BOOL
  185. _IsAlNum(void *LocaleBase, struct Locale *locale, unsigned long character)
  186. {
  187. struct Caos    MyCaos;
  188.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  189. //    MyCaos.M68kStart    =    NULL;
  190. //    MyCaos.M68kSize        =    0;
  191.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  192. //    MyCaos.PPCStart        =    NULL;
  193. //    MyCaos.PPCSize        =    0;
  194.     MyCaos.a0        =(ULONG) locale;
  195.     MyCaos.d0        =(ULONG) character;
  196.     MyCaos.caos_Un.Offset    =    (-84);
  197.     MyCaos.a6        =(ULONG) LocaleBase;    
  198.     return((BOOL)PPCCallOS(&MyCaos));
  199. }
  200.  
  201. #define    IsAlpha(locale, character)    _IsAlpha(LOCALE_BASE_NAME, locale, character)
  202.  
  203. static __inline BOOL
  204. _IsAlpha(void *LocaleBase, struct Locale *locale, unsigned long character)
  205. {
  206. struct Caos    MyCaos;
  207.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  208. //    MyCaos.M68kStart    =    NULL;
  209. //    MyCaos.M68kSize        =    0;
  210.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  211. //    MyCaos.PPCStart        =    NULL;
  212. //    MyCaos.PPCSize        =    0;
  213.     MyCaos.a0        =(ULONG) locale;
  214.     MyCaos.d0        =(ULONG) character;
  215.     MyCaos.caos_Un.Offset    =    (-90);
  216.     MyCaos.a6        =(ULONG) LocaleBase;    
  217.     return((BOOL)PPCCallOS(&MyCaos));
  218. }
  219.  
  220. #define    IsCntrl(locale, character)    _IsCntrl(LOCALE_BASE_NAME, locale, character)
  221.  
  222. static __inline BOOL
  223. _IsCntrl(void *LocaleBase, struct Locale *locale, unsigned long character)
  224. {
  225. struct Caos    MyCaos;
  226.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  227. //    MyCaos.M68kStart    =    NULL;
  228. //    MyCaos.M68kSize        =    0;
  229.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  230. //    MyCaos.PPCStart        =    NULL;
  231. //    MyCaos.PPCSize        =    0;
  232.     MyCaos.a0        =(ULONG) locale;
  233.     MyCaos.d0        =(ULONG) character;
  234.     MyCaos.caos_Un.Offset    =    (-96);
  235.     MyCaos.a6        =(ULONG) LocaleBase;    
  236.     return((BOOL)PPCCallOS(&MyCaos));
  237. }
  238.  
  239. #define    IsDigit(locale, character)    _IsDigit(LOCALE_BASE_NAME, locale, character)
  240.  
  241. static __inline BOOL
  242. _IsDigit(void *LocaleBase, struct Locale *locale, unsigned long character)
  243. {
  244. struct Caos    MyCaos;
  245.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  246. //    MyCaos.M68kStart    =    NULL;
  247. //    MyCaos.M68kSize        =    0;
  248.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  249. //    MyCaos.PPCStart        =    NULL;
  250. //    MyCaos.PPCSize        =    0;
  251.     MyCaos.a0        =(ULONG) locale;
  252.     MyCaos.d0        =(ULONG) character;
  253.     MyCaos.caos_Un.Offset    =    (-102);
  254.     MyCaos.a6        =(ULONG) LocaleBase;    
  255.     return((BOOL)PPCCallOS(&MyCaos));
  256. }
  257.  
  258. #define    IsGraph(locale, character)    _IsGraph(LOCALE_BASE_NAME, locale, character)
  259.  
  260. static __inline BOOL
  261. _IsGraph(void *LocaleBase, struct Locale *locale, unsigned long character)
  262. {
  263. struct Caos    MyCaos;
  264.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  265. //    MyCaos.M68kStart    =    NULL;
  266. //    MyCaos.M68kSize        =    0;
  267.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  268. //    MyCaos.PPCStart        =    NULL;
  269. //    MyCaos.PPCSize        =    0;
  270.     MyCaos.a0        =(ULONG) locale;
  271.     MyCaos.d0        =(ULONG) character;
  272.     MyCaos.caos_Un.Offset    =    (-108);
  273.     MyCaos.a6        =(ULONG) LocaleBase;    
  274.     return((BOOL)PPCCallOS(&MyCaos));
  275. }
  276.  
  277. #define    IsLower(locale, character)    _IsLower(LOCALE_BASE_NAME, locale, character)
  278.  
  279. static __inline BOOL
  280. _IsLower(void *LocaleBase, struct Locale *locale, unsigned long character)
  281. {
  282. struct Caos    MyCaos;
  283.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  284. //    MyCaos.M68kStart    =    NULL;
  285. //    MyCaos.M68kSize        =    0;
  286.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  287. //    MyCaos.PPCStart        =    NULL;
  288. //    MyCaos.PPCSize        =    0;
  289.     MyCaos.a0        =(ULONG) locale;
  290.     MyCaos.d0        =(ULONG) character;
  291.     MyCaos.caos_Un.Offset    =    (-114);
  292.     MyCaos.a6        =(ULONG) LocaleBase;    
  293.     return((BOOL)PPCCallOS(&MyCaos));
  294. }
  295.  
  296. #define    IsPrint(locale, character)    _IsPrint(LOCALE_BASE_NAME, locale, character)
  297.  
  298. static __inline BOOL
  299. _IsPrint(void *LocaleBase, struct Locale *locale, unsigned long character)
  300. {
  301. struct Caos    MyCaos;
  302.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  303. //    MyCaos.M68kStart    =    NULL;
  304. //    MyCaos.M68kSize        =    0;
  305.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  306. //    MyCaos.PPCStart        =    NULL;
  307. //    MyCaos.PPCSize        =    0;
  308.     MyCaos.a0        =(ULONG) locale;
  309.     MyCaos.d0        =(ULONG) character;
  310.     MyCaos.caos_Un.Offset    =    (-120);
  311.     MyCaos.a6        =(ULONG) LocaleBase;    
  312.     return((BOOL)PPCCallOS(&MyCaos));
  313. }
  314.  
  315. #define    IsPunct(locale, character)    _IsPunct(LOCALE_BASE_NAME, locale, character)
  316.  
  317. static __inline BOOL
  318. _IsPunct(void *LocaleBase, struct Locale *locale, unsigned long character)
  319. {
  320. struct Caos    MyCaos;
  321.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  322. //    MyCaos.M68kStart    =    NULL;
  323. //    MyCaos.M68kSize        =    0;
  324.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  325. //    MyCaos.PPCStart        =    NULL;
  326. //    MyCaos.PPCSize        =    0;
  327.     MyCaos.a0        =(ULONG) locale;
  328.     MyCaos.d0        =(ULONG) character;
  329.     MyCaos.caos_Un.Offset    =    (-126);
  330.     MyCaos.a6        =(ULONG) LocaleBase;    
  331.     return((BOOL)PPCCallOS(&MyCaos));
  332. }
  333.  
  334. #define    IsSpace(locale, character)    _IsSpace(LOCALE_BASE_NAME, locale, character)
  335.  
  336. static __inline BOOL
  337. _IsSpace(void *LocaleBase, struct Locale *locale, unsigned long character)
  338. {
  339. struct Caos    MyCaos;
  340.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  341. //    MyCaos.M68kStart    =    NULL;
  342. //    MyCaos.M68kSize        =    0;
  343.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  344. //    MyCaos.PPCStart        =    NULL;
  345. //    MyCaos.PPCSize        =    0;
  346.     MyCaos.a0        =(ULONG) locale;
  347.     MyCaos.d0        =(ULONG) character;
  348.     MyCaos.caos_Un.Offset    =    (-132);
  349.     MyCaos.a6        =(ULONG) LocaleBase;    
  350.     return((BOOL)PPCCallOS(&MyCaos));
  351. }
  352.  
  353. #define    IsUpper(locale, character)    _IsUpper(LOCALE_BASE_NAME, locale, character)
  354.  
  355. static __inline BOOL
  356. _IsUpper(void *LocaleBase, struct Locale *locale, unsigned long character)
  357. {
  358. struct Caos    MyCaos;
  359.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  360. //    MyCaos.M68kStart    =    NULL;
  361. //    MyCaos.M68kSize        =    0;
  362.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  363. //    MyCaos.PPCStart        =    NULL;
  364. //    MyCaos.PPCSize        =    0;
  365.     MyCaos.a0        =(ULONG) locale;
  366.     MyCaos.d0        =(ULONG) character;
  367.     MyCaos.caos_Un.Offset    =    (-138);
  368.     MyCaos.a6        =(ULONG) LocaleBase;    
  369.     return((BOOL)PPCCallOS(&MyCaos));
  370. }
  371.  
  372. #define    IsXDigit(locale, character)    _IsXDigit(LOCALE_BASE_NAME, locale, character)
  373.  
  374. static __inline BOOL
  375. _IsXDigit(void *LocaleBase, struct Locale *locale, unsigned long character)
  376. {
  377. struct Caos    MyCaos;
  378.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  379. //    MyCaos.M68kStart    =    NULL;
  380. //    MyCaos.M68kSize        =    0;
  381.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  382. //    MyCaos.PPCStart        =    NULL;
  383. //    MyCaos.PPCSize        =    0;
  384.     MyCaos.a0        =(ULONG) locale;
  385.     MyCaos.d0        =(ULONG) character;
  386.     MyCaos.caos_Un.Offset    =    (-144);
  387.     MyCaos.a6        =(ULONG) LocaleBase;    
  388.     return((BOOL)PPCCallOS(&MyCaos));
  389. }
  390.  
  391. #define    OpenCatalogA(locale, name, tags)    _OpenCatalogA(LOCALE_BASE_NAME, locale, name, tags)
  392.  
  393. static __inline struct Catalog *
  394. _OpenCatalogA(void *LocaleBase, struct Locale *locale, STRPTR name, struct TagItem *tags)
  395. {
  396. struct Caos    MyCaos;
  397.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  398. //    MyCaos.M68kStart    =    NULL;
  399. //    MyCaos.M68kSize        =    0;
  400.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  401. //    MyCaos.PPCStart        =    NULL;
  402. //    MyCaos.PPCSize        =    0;
  403.     MyCaos.a0        =(ULONG) locale;
  404.     MyCaos.a1        =(ULONG) name;
  405.     MyCaos.a2        =(ULONG) tags;
  406.     MyCaos.caos_Un.Offset    =    (-150);
  407.     MyCaos.a6        =(ULONG) LocaleBase;    
  408.     return((struct Catalog *)PPCCallOS(&MyCaos));
  409. }
  410.  
  411. #ifndef NO_PPCINLINE_STDARG
  412. #define OpenCatalog(a0, a1, tags...) \
  413.     ({ULONG _tags[] = { tags }; OpenCatalogA((a0), (a1), (struct TagItem *)_tags);})
  414. #endif /* !NO_PPCINLINE_STDARG */
  415.  
  416. #define    OpenLocale(name)    _OpenLocale(LOCALE_BASE_NAME, name)
  417.  
  418. static __inline struct Locale *
  419. _OpenLocale(void *LocaleBase, STRPTR name)
  420. {
  421. struct Caos    MyCaos;
  422.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  423. //    MyCaos.M68kStart    =    NULL;
  424. //    MyCaos.M68kSize        =    0;
  425.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  426. //    MyCaos.PPCStart        =    NULL;
  427. //    MyCaos.PPCSize        =    0;
  428.     MyCaos.a0        =(ULONG) name;
  429.     MyCaos.caos_Un.Offset    =    (-156);
  430.     MyCaos.a6        =(ULONG) LocaleBase;    
  431.     return((struct Locale *)PPCCallOS(&MyCaos));
  432. }
  433.  
  434. #define    ParseDate(locale, date, fmtTemplate, getCharFunc)    _ParseDate(LOCALE_BASE_NAME, locale, date, fmtTemplate, getCharFunc)
  435.  
  436. static __inline BOOL
  437. _ParseDate(void *LocaleBase, struct Locale *locale, struct DateStamp *date, STRPTR fmtTemplate, struct Hook *getCharFunc)
  438. {
  439. struct Caos    MyCaos;
  440.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  441. //    MyCaos.M68kStart    =    NULL;
  442. //    MyCaos.M68kSize        =    0;
  443.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  444. //    MyCaos.PPCStart        =    NULL;
  445. //    MyCaos.PPCSize        =    0;
  446.     MyCaos.a0        =(ULONG) locale;
  447.     MyCaos.a1        =(ULONG) date;
  448.     MyCaos.a2        =(ULONG) fmtTemplate;
  449.     MyCaos.a3        =(ULONG) getCharFunc;
  450.     MyCaos.caos_Un.Offset    =    (-162);
  451.     MyCaos.a6        =(ULONG) LocaleBase;    
  452.     return((BOOL)PPCCallOS(&MyCaos));
  453. }
  454.  
  455. #define    StrConvert(locale, string, buffer, bufferSize, type)    _StrConvert(LOCALE_BASE_NAME, locale, string, buffer, bufferSize, type)
  456.  
  457. static __inline ULONG
  458. _StrConvert(void *LocaleBase, struct Locale *locale, STRPTR string, APTR buffer, unsigned long bufferSize, unsigned long type)
  459. {
  460. struct Caos    MyCaos;
  461.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  462. //    MyCaos.M68kStart    =    NULL;
  463. //    MyCaos.M68kSize        =    0;
  464.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  465. //    MyCaos.PPCStart        =    NULL;
  466. //    MyCaos.PPCSize        =    0;
  467.     MyCaos.a0        =(ULONG) locale;
  468.     MyCaos.a1        =(ULONG) string;
  469.     MyCaos.a2        =(ULONG) buffer;
  470.     MyCaos.d0        =(ULONG) bufferSize;
  471.     MyCaos.d1        =(ULONG) type;
  472.     MyCaos.caos_Un.Offset    =    (-174);
  473.     MyCaos.a6        =(ULONG) LocaleBase;    
  474.     return((ULONG)PPCCallOS(&MyCaos));
  475. }
  476.  
  477. #define    StrnCmp(locale, string1, string2, length, type)    _StrnCmp(LOCALE_BASE_NAME, locale, string1, string2, length, type)
  478.  
  479. static __inline LONG
  480. _StrnCmp(void *LocaleBase, struct Locale *locale, STRPTR string1, STRPTR string2, long length, unsigned long type)
  481. {
  482. struct Caos    MyCaos;
  483.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  484. //    MyCaos.M68kStart    =    NULL;
  485. //    MyCaos.M68kSize        =    0;
  486.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  487. //    MyCaos.PPCStart        =    NULL;
  488. //    MyCaos.PPCSize        =    0;
  489.     MyCaos.a0        =(ULONG) locale;
  490.     MyCaos.a1        =(ULONG) string1;
  491.     MyCaos.a2        =(ULONG) string2;
  492.     MyCaos.d0        =(ULONG) length;
  493.     MyCaos.d1        =(ULONG) type;
  494.     MyCaos.caos_Un.Offset    =    (-180);
  495.     MyCaos.a6        =(ULONG) LocaleBase;    
  496.     return((LONG)PPCCallOS(&MyCaos));
  497. }
  498.  
  499. #endif /* SASC Pragmas */
  500. #endif /* !_PPCPRAGMA_LOCALE_H */
  501.